/*
 * 
 * Proj. Wireless - UFRN
 * JFrameStep
 * 
 */

package gui;

import java.awt.BorderLayout;
import java.awt.Component;
import java.awt.Dimension;
import java.awt.GridLayout;
import java.awt.event.InputEvent;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.util.ArrayList;
import javax.swing.*;
import metodologia.Etapa;
import org.jdesktop.swingx.JXTable;
import org.jdesktop.swingx.JXTableHeader;

/**
 * Frame com as tarefas para executar - 3º tela do processo
 * 
 * @author PW-UFRN
 */
public class JFPStep extends javax.swing.JFrame {
    
    /** Armazena o titulo do software */
    private String title;    
    /** Armazena o nome do conjunto de etapas */
    private String name;
    /** Armazena as etapas/tarefas */
    private ArrayList<Etapa> lEtapas1;
    
    /** Armazena a quantidade de tarefas (checkboxs) */
    private int qtyBox;
    /** Armazena os titulos das tarefas */
    private String titleStep[];
    /** Armazena as descrições das tarefas */
    private String descriptStep[];
    /** Armazena os numeros de linhas da tabelas */
    private ArrayList<Integer> rowsTable;
    /** Armazena os numeros de colunas da tabelas */
    private ArrayList<Integer> colTable;
    /** Armazena as tabelas das tarefas */
    private ArrayList<ArrayList<ArrayList<String>>> tableItens;
    /** Armazena os titulos das tabelas das tarefas */
    private ArrayList<ArrayList<String>> titleTable;
    /** Armazena o estado da tabela, se foi modificada ou continua em null */
    private ArrayList<Boolean> active;
    
    private int progress;       // variável que armazena a quantidade de checkboxes marcados (progresso desta etapa)
    private int stage;       // variável para armazenar a que tópico da metodologia pertence esta tela        
    private boolean finished;
    
    // Variables Interface
    /** Armazena os checkboxs existentes na tela */
    private JCheckBox cItens[];
    /** Armazena as tabelas dos checkboxs da tela */
    private JPanel tItens[];   
    
    private JPanel jplCheckBox; // Painel de CheckBoxs
    private JScrollPane jspCheckBox;
    private JPanel jplDescript; // Painel de Descrições de passos
    private JScrollPane jspDescript;
    private JTextArea jtaDescript;
    private JPanel jplTable; // Painel de tabela
    private JProgressBar jProgressBar1; // Barra de progresso
    private JTabbedPane jtpConfig; // Variável dos paneis de configuração
    private JButton jbFinished; // Botão de finalizar as etapas    
    private JXTable table;
    private JScrollPane jspTable;
    private JPanel jplObservation; // Painel de Observaçoes das etapas
    private JScrollPane jspObservation;
    private JTextArea jtaObservation;
    
    private String observation;

    /**
     * Construtor da classe
     */
    public JFPStep() {
        
        /** Configuração da tela */
        
        setLocationRelativeTo(null);
        
        ImageIcon imagemTituloJanela = new ImageIcon(getClass().getResource("/ImageFiles/icon_PW.png"));
        setIconImage(imagemTituloJanela.getImage());
        
        title = "PW-Execute";
        setTitle(title);
        
        setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
        
        /** Inicialização de variáveis */
        
        name = "";
        observation = "";
        lEtapas1 = new ArrayList<>();
        qtyBox = 0;
        titleStep = new String[qtyBox];
        descriptStep = new String[qtyBox];
        rowsTable = new ArrayList<>();
        colTable = new ArrayList<>();

        initCount();
        initComponents();
        
    }
    
    /**
     * Seta os checkboxs para marcados
     */
    public void setAllSelected(){
        for(int i=0; i<qtyBox; i++){
            cItens[i].setSelected(true);
        }
    }
    
    /**
     * Seta os checkboxs para desmarcados
     */
    public void setAllUnselected(){
        progress=0;
        for(int i=0; i<qtyBox; i++){
            cItens[i].setSelected(false);
        }
    }
    
    /**
     * Inicializa o progresso para zero.
     */
    private void initCount(){
        progress=0;
    }    
    
    /**
     * Método que atualiza a barra de progresso 
     * @param i: indice do checkbox
     */
    private void updateProgress(int i){
        
        int count = 0;
        for (int j=0; j<qtyBox; j++){
            if(cItens[j].isSelected()){
                count++;
            }
            else{
                break;
            }
        }
        jProgressBar1.setValue(count);
        
    }
    
    /**
     * Incrementa o valor do progresso
     */
    private void incProgress(){
        progress++;
    }
    
    /**
     * Decrementa o valor do progresso
     */
    private void decProgress(){
        progress--;
    }
    
    /**
     * Evento para quando fechar a tela
     */
    private void onCloseWindows(){
        addWindowListener(new WindowAdapter() {  
            @Override
            public void windowClosed(WindowEvent e) { 
                check();
                uploadObservation();
                
                if((getProgress() == qtyBox)&&(qtyBox != 0)){
                    setFinished(true);
                }
                else {
                    setFinished(false);
                }
                
                setVisible(false);
            }  
        });
    }
    
    /**
     * Constrói o frame
     * 
     */
    private void constructFrame(){
        
        //Adiciona as características de cada checkboxs
        featuresCheckBox();
        
        //
        // Inicialização e configuração dos componentes
        //
        jplCheckBox = new JPanel(new GridLayout(0, 1, 5, 5));
        jspCheckBox = new JScrollPane(jplCheckBox, 
                JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED, 
                JScrollPane.HORIZONTAL_SCROLLBAR_NEVER);
        jspCheckBox.setBorder(javax.swing.BorderFactory.createTitledBorder(null, "Tarefas", 
            javax.swing.border.TitledBorder.LEFT, javax.swing.border.TitledBorder.DEFAULT_POSITION, 
            new java.awt.Font("Calibri", 1, 12), new java.awt.Color(0, 0, 0)));
        jspCheckBox.setPreferredSize(new Dimension(500, 350));
        jspCheckBox.setViewportView(jplCheckBox);
        
        jtaDescript = new JTextArea("");
        jspDescript = new JScrollPane(jtaDescript, 
                JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED, 
                JScrollPane.HORIZONTAL_SCROLLBAR_AS_NEEDED);
        jspDescript.setViewportView(jtaDescript);
        jtaDescript.setEditable(false);
        
        jtaObservation = new JTextArea("");
        jtaObservation.addKeyListener(new java.awt.event.KeyAdapter() {
                @Override
                public void keyTyped(java.awt.event.KeyEvent evt) {
                    jObservationKeyTyped(evt);
                }
        });
        jspObservation = new JScrollPane(jtaObservation,
                JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED, 
                JScrollPane.HORIZONTAL_SCROLLBAR_AS_NEEDED);
        jspObservation.setViewportView(jtaObservation);
        
        jplTable = new JPanel();
        jspTable = new JScrollPane(jplTable, 
                JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED, 
                JScrollPane.HORIZONTAL_SCROLLBAR_AS_NEEDED);
        table = new JXTable();
        
        jplTable.add(table);
        jspTable.setViewportView(jplTable);
        
        jProgressBar1 = new JProgressBar(0, qtyBox);
        jtpConfig = new JTabbedPane();
        
        jbFinished = new JButton("Finalizar");
        jbFinished.addActionListener(new java.awt.event.ActionListener() {
            @Override
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                jbFinishedActionPerformed(evt);
            }
        });
        
        //
        // Redesenhando o frame
        //
        setLayout(new BorderLayout());
        
        add(jspCheckBox, BorderLayout.NORTH);
        
        jtpConfig.addTab("Descrição", jspDescript);
        jtpConfig.addTab("Tabela", jspTable);
        jtpConfig.addTab("Observações", jspObservation);
        
        add(jtpConfig);
        
        jProgressBar1.setPreferredSize(new Dimension(250 - jbFinished.getWidth(), 15));
        
        JPanel aux = new JPanel();
        aux.add(jProgressBar1);
        aux.add(jbFinished);
        
        add(aux, BorderLayout.SOUTH);
        
        pack();
        setSize(400, 600);
        
        // Métodos para adicionar as informações necessárias
        addCheckBoxs();
        
    }
    
    private void addListener(){
        int i;
        for(i=0; i<qtyBox; i++){
            final int aux = i;
            cItens[i].addMouseListener(new java.awt.event.MouseAdapter() {
                @Override
                public void mouseClicked(java.awt.event.MouseEvent evt){
                    if ((evt.getModifiers() & InputEvent.BUTTON1_MASK) != 0) {  
                        uploadObservation();
                        jCheckBoxMouseClicked(evt, aux);
                    }  
                    if ((evt.getModifiers() & InputEvent.BUTTON2_MASK) != 0) {
                        uploadObservation();
                        cItens[aux].requestFocus();
                    }  
                    if ((evt.getModifiers() & InputEvent.BUTTON3_MASK) != 0) {
                        uploadObservation();
                        jCheckBoxMouseClicked3(evt, aux);
                    } 
                }

                @Override
                public void mousePressed(java.awt.event.MouseEvent evt){
                    jCheckBoxMousePressed(evt, aux);
                }
                @Override
                public void mouseEntered(java.awt.event.MouseEvent evt){
                    jCheckBoxMouseEntered(evt, aux);
                }
            });
            
            cItens[i].addFocusListener(new java.awt.event.FocusAdapter() {
                @Override
                public void focusGained(java.awt.event.FocusEvent evt){
                    jCheckBoxFocusGained(evt, aux);
                };  
            });
            
            cItens[i].addKeyListener(new java.awt.event.KeyAdapter() {
                
                @Override
                public void keyPressed(java.awt.event.KeyEvent evt){
                    jCheckBoxKeyPressed(evt, aux);
                };
            });
            
            cItens[i].addItemListener(new java.awt.event.ItemListener() {

                @Override
                public void itemStateChanged(java.awt.event.ItemEvent evt) {
                    jCheckBoxItemStateChanged(evt, aux);
                };
            });
            
        }
    }
    
    /**
     * Atualiza o valor do progresso
     */
    private void check(){
        initCount();
        for(int i =0; i<cItens.length; i++){
            if (cItens[i].isSelected()) { incProgress(); }
        }
    }
    
    private void jCheckBoxMouseClicked(java.awt.event.MouseEvent evt, int i) {

    }
    
    private void jCheckBoxMouseClicked3(java.awt.event.MouseEvent evt, int i) {
        cItens[i].requestFocus();
    }

    private void jCheckBoxMousePressed(java.awt.event.MouseEvent evt, int i) {
        
    }

    private void jCheckBoxMouseEntered(java.awt.event.MouseEvent evt, int i) {
        
    }
    
    private void jCheckBoxFocusGained(java.awt.event.FocusEvent evt, int i){
        jtaDescript.setText(descriptStep[i]);
        
        jplTable.removeAll();
        jplTable.add(tItens[i]);
        jplTable.repaint();
        jspTable.repaint();
    }
    
    private void jCheckBoxKeyPressed(java.awt.event.KeyEvent evt, int i){

    }
    
    private void jCheckBoxItemStateChanged(java.awt.event.ItemEvent evt, int i) {
        if (isVisible()){ //Verifica se a janela está visivel para o operador
            checkListened(i);
        }
    }
    
    private void jObservationKeyTyped(java.awt.event.KeyEvent evt) {
        //Coloca pra salvar em algum lugar        
        uploadObservation();
    }
    
    private void uploadObservation(){
        observation = jtaObservation.getText();
    }
    
    /**
     * Trata todos os eventos que seleciona o checkBox.
     * @param i 
     */
    private void checkListened(int i){
        
        if(cItens[i].isSelected()){

            /*
             * Verificando para solicitar adição de campos da tabela
             */
            if(lEtapas1.get(i).isPlanilha()){
                
                ArrayList<Boolean> rowsEmpty = new ArrayList<>();
                ArrayList<Boolean> rowsComplete = new ArrayList<>();
                ArrayList<Boolean> rowsIncomplete = new ArrayList<>();
                
                if(lEtapas1.get(i).getTitulos().size() == colTable.get(i)){
                    for(int j = 0; j<rowsTable.get(i); j++){
                        boolean aux1 = false; //Verifica se a linha tem pelo menos um campo vazio
                        boolean aux2 = false; //Verifica se a linha tem pelo menos um campo não vazio
                        
                        for(int u = 0; u<lEtapas1.get(i).getTitulos().size(); u++){
                            if (((JXTable) tItens[i].getComponent(1)).getValueAt(j, u) != null){
                                if(!(((JXTable) tItens[i].getComponent(1)).getValueAt(j, u).equals(""))){
                                    aux2 = true;
                                } else{
                                    aux1 = true;
                                }
                            } else{
                                aux1 = true;
                            }
                        }

                        if (aux1){ //Tem pelo menos um campo vazio
                            if(aux2){ //Tem pelo menos um campo não vazio
                                rowsEmpty.add(false);
                                rowsComplete.add(false);
                                rowsIncomplete.add(true);
                            } else{
                                rowsEmpty.add(true);
                                rowsComplete.add(false);
                                rowsIncomplete.add(false);                            }
                        } else{
                            rowsEmpty.add(false);
                            rowsComplete.add(true);
                            rowsIncomplete.add(false);
                        }
                    }
                } else{
                    for(int j = 0; j<rowsTable.get(i); j++){
                        boolean aux1 = false; //Verifica se a linha tem pelo menos um campo vazio
                        boolean aux2 = false; //Verifica se a linha tem pelo menos um campo não vazio
                        
                        for(int u = 0; u<colTable.get(i); u++){
                            if (((JXTable) tItens[i].getComponent(1)).getValueAt(j, u) != null){
                                if(!(((JXTable) tItens[i].getComponent(1)).getValueAt(j, u).equals(""))){
                                    aux2 = true;
                                } else{
                                    aux1 = true;
                                }
                            } else{
                                aux1 = true;
                            }
                        }

                        if (aux1){ //Tem pelo menos um campo vazio
                            if(aux2){ //Tem pelo menos um campo não vazio
                                rowsEmpty.add(false);
                                rowsComplete.add(false);
                                rowsIncomplete.add(true);
                            } else{
                                rowsEmpty.add(true);
                                rowsComplete.add(false);
                                rowsIncomplete.add(false);                            }
                        } else{
                            rowsEmpty.add(false);
                            rowsComplete.add(true);
                            rowsIncomplete.add(false);
                        }
                    }
                }
                
                boolean tableRowsComplete = false;
                boolean tableRowsIncomplete = false;
                
                if(rowsEmpty.size() == rowsComplete.size()){
                    if(rowsComplete.size() == rowsIncomplete.size()){
                        for(int d=0; d<rowsEmpty.size(); d++){
                            if(rowsIncomplete.get(d)){
                                tableRowsIncomplete = true;
                            } else{
                                if(rowsComplete.get(d)){
                                    tableRowsComplete = true;
                                }
                            }
                        }
                        
                        if(!tableRowsComplete){
                            if(!tableRowsIncomplete){
                                String aux_message = "Tabela de dados da tarefa não foi preenchida.";
                                JOptionPane.showMessageDialog(null, aux_message, "Dados da tarefa", JOptionPane.WARNING_MESSAGE);

                                jtpConfig.setSelectedComponent(jspTable);
                                jtpConfig.requestFocus();
                                jspTable.repaint();
                                jspTable.revalidate();
                                jtpConfig.repaint();
                                jtpConfig.revalidate();
                            } else{
                                String aux_message = "Tabela de dados da tarefa não foi preenchida. "
                                    + "\n Obs.: Cada linha deve ter todos os campos preenchidos.";
                                JOptionPane.showMessageDialog(null, aux_message, "Dados da tarefa", JOptionPane.WARNING_MESSAGE);

                                jtpConfig.setSelectedComponent(jspTable);
                                jtpConfig.requestFocus();
                                jspTable.repaint();
                                jspTable.revalidate();
                                jtpConfig.repaint();
                                jtpConfig.revalidate();
                            }    
                        } else{
                            if(tableRowsIncomplete){
                                String aux_message = "Tabela de dados da tarefa não foi preenchida. "
                                    + "\n Obs.: Cada linha deve ter todos os campos preenchidos.";
                                JOptionPane.showMessageDialog(null, aux_message, "Dados da tarefa", JOptionPane.WARNING_MESSAGE);

                                jtpConfig.setSelectedComponent(jspTable);
                                jtpConfig.requestFocus();
                                jspTable.repaint();
                                jspTable.revalidate();
                                jtpConfig.repaint();
                                jtpConfig.revalidate();
                            }
                        }
                        
                    }
                }
            }

            /*
             * Verificando novamente
             */

            ArrayList<Boolean> rowsEmpty = new ArrayList<>();
            ArrayList<Boolean> rowsComplete = new ArrayList<>();
            ArrayList<Boolean> rowsIncomplete = new ArrayList<>();

            if(lEtapas1.get(i).getTitulos().size() == colTable.get(i)){
                for(int j = 0; j<rowsTable.get(i); j++){
                    boolean aux1 = false; //Verifica se a linha tem pelo menos um campo vazio
                    boolean aux2 = false; //Verifica se a linha tem pelo menos um campo não vazio

                    for(int u = 0; u<lEtapas1.get(i).getTitulos().size(); u++){
                        if (((JXTable) tItens[i].getComponent(1)).getValueAt(j, u) != null){
                            if(!(((JXTable) tItens[i].getComponent(1)).getValueAt(j, u).equals(""))){
                                aux2 = true;
                            } else{
                                aux1 = true;
                            }
                        } else{
                            aux1 = true;
                        }
                    }

                    if (aux1){ //Tem pelo menos um campo vazio
                        if(aux2){ //Tem pelo menos um campo não vazio
                            rowsEmpty.add(false);
                            rowsComplete.add(false);
                            rowsIncomplete.add(true);
                        } else{
                            rowsEmpty.add(true);
                            rowsComplete.add(false);
                            rowsIncomplete.add(false);                            }
                    } else{
                        rowsEmpty.add(false);
                        rowsComplete.add(true);
                        rowsIncomplete.add(false);
                    }
                }
            } else{
                for(int j = 0; j<rowsTable.get(i); j++){
                    boolean aux1 = false; //Verifica se a linha tem pelo menos um campo vazio
                    boolean aux2 = false; //Verifica se a linha tem pelo menos um campo não vazio

                    for(int u = 0; u<colTable.get(i); u++){
                        if (((JXTable) tItens[i].getComponent(1)).getValueAt(j, u) != null){
                            if(!(((JXTable) tItens[i].getComponent(1)).getValueAt(j, u).equals(""))){
                                aux2 = true;
                            } else{
                                aux1 = true;
                            }
                        } else{
                            aux1 = true;
                        }
                    }

                    if (aux1){ //Tem pelo menos um campo vazio
                        if(aux2){ //Tem pelo menos um campo não vazio
                            rowsEmpty.add(false);
                            rowsComplete.add(false);
                            rowsIncomplete.add(true);
                        } else{
                            rowsEmpty.add(true);
                            rowsComplete.add(false);
                            rowsIncomplete.add(false);                            }
                    } else{
                        rowsEmpty.add(false);
                        rowsComplete.add(true);
                        rowsIncomplete.add(false);
                    }
                }
            }

            boolean tableEmpty = false;
            boolean tableRowsComplete = false;
            boolean tableRowsIncomplete = false;

            if(rowsEmpty.size() == rowsComplete.size()){
                if(rowsComplete.size() == rowsIncomplete.size()){
                    for(int d=0; d<rowsEmpty.size(); d++){
                        if(rowsIncomplete.get(d)){
                            tableRowsIncomplete = true;
                        } else{
                            if(rowsComplete.get(d)){
                                tableRowsComplete = true;
                            }
                        }
                    }

                    if((!tableRowsComplete) && (!tableRowsIncomplete)){
                        tableEmpty = true;
                    } else {
                        tableEmpty = false;
                    }
                }
            }
    
            //Caso alguma linha da tabela tenha sido completada(Checkbox - ok)
            if(((!tableEmpty) && (!tableRowsIncomplete)) && (tableRowsComplete)){
                incProgress();
                jplTable.removeAll();
                jplTable.add(tItens[i]);
                if(i != qtyBox-1){
                    cItens[i+1].setEnabled(true);
                    cItens[i+1].setVisible(true);
                }
                cItens[i].setSelected(true);
            } else if(!lEtapas1.get(i).isPlanilha()){ //Caso não existe tabela
                if(i != qtyBox-1){
                    cItens[i+1].setEnabled(true);
                    cItens[i+1].setVisible(true);
                }
                cItens[i].setSelected(true);
            } else{ //Caso existe tabela e não tem linha completa
                decProgress();
                jplTable.removeAll();
                cItens[i].setSelected(false);
            }        
            jplTable.repaint();
            jspTable.repaint();
            jtpConfig.repaint();

            updateProgress(i);
            
        } else{            
            for(int g=i+1; g<cItens.length; g++){
                cItens[g].setSelected(false);
                cItens[g].setVisible(false);
            }
        }
        
    }
    
    /**
     * Adiciona os checkboxs da tela
     */
    private void addCheckBoxs(){ 
        int i;
        Component[] listComponents;
        
        //Adiciona checkboxs a tela
        for(i=0; i<qtyBox; i++){
            JCheckBox cb = new JCheckBox(getTituloEtapa()[i]);
            if(i == 0){
                cb.setEnabled(true);
                cb.setVisible(true);
            } else{
                cb.setEnabled(false);
                cb.setVisible(false);
            }
            jplCheckBox.add(cb);
        }
        jplCheckBox.repaint();
        
        //Recupera os checkboxs e coloca na várivel de armazenamento (cItens)
        listComponents = jplCheckBox.getComponents();        
        for(i=0; i<listComponents.length; i++){
            cItens[i] = (JCheckBox) listComponents[i];
            if(cItens[i].isFocusCycleRoot()){ 
                jtaDescript.setText(descriptStep[i]); 
            }
        }
        
        //Adiciona as funcionalidades dos checkboxs
        addListener();
        
    }

    /**
     * Configura as características dos checkboxs,
     * por exemplo: descrição, tabela, observação etc.
     */
    private void featuresCheckBox(){
        
        JPanel aux;
        JXTable aux_table;
        JXTableHeader aux_header;
        
        //Adicionando as descrições(tdescript) de cada Etapa
        for(int i=0; i<lEtapas1.size(); i++){
            titleStep[i] = lEtapas1.get(i).getTitulo();
            descriptStep[i] = lEtapas1.get(i).getDescricao();
            if(lEtapas1.get(i).isPlanilha()){
                if (lEtapas1.get(i).getnLinhas().equals("") || lEtapas1.get(i).getnLinhas() == null){
                    rowsTable.add(0);
                    lEtapas1.get(i).setPlanilha(false);
                } else{
                    rowsTable.add(Integer.parseInt(lEtapas1.get(i).getnLinhas()));
                }
                
                if (lEtapas1.get(i).getnColunas().equals("") || lEtapas1.get(i).getnColunas() == null){
                    colTable.add(0);
                    lEtapas1.get(i).setPlanilha(false);
                } else{
                    colTable.add(Integer.parseInt(lEtapas1.get(i).getnColunas()));
                }
            } else{
                rowsTable.add(0);
                colTable.add(0);
            }
        }
        
        //Adicionando as tabelas de cada Etapa
        for(int i = 0; i<lEtapas1.size(); i++){
            if(lEtapas1.get(i).isPlanilha()){
                
                titleTable.add(lEtapas1.get(i).getTitulos());
                aux_table = new JXTable(rowsTable.get(i), colTable.get(i));
                
                for (int g = 0; g<rowsTable.get(i); g++){
                    for (int k = 0; k<colTable.get(i); k++){
                        aux_table.setValueAt("", g, k);
                    }
                }

                if (lEtapas1.get(i).getTitulos().size() == colTable.get(i)){
                    for (int j = 0; j<lEtapas1.get(i).getTitulos().size(); j++){
                        //Adicionando os titulos das colunas
                        aux_table.getColumnModel().getColumn(j).setHeaderValue(lEtapas1.get(i).getTitulos().get(j));
                        int r = lEtapas1.get(i).getTitulos().get(j).length() *8;
                        if(r<50){ r = 50; }
                        aux_table.getColumnModel().getColumn(j).setPreferredWidth(r);
                    }
                } else{
                    System.out.println("[Erro]" + lEtapas1.get(i).getTitulo() + " - Número de colunas diferente do número de títulos das colunas");
                    for (int j = 0; j<colTable.get(i); j++){
                        //Adicionando os titulos das colunas
                        if (lEtapas1.get(i).getTitulos().size() > j){
                            if((lEtapas1.get(i).getTitulos().get(j) == null) || (lEtapas1.get(i).getTitulos().get(j).equals(""))) {
                                aux_table.getColumnModel().getColumn(j).setHeaderValue(" ");
                            } else{
                                aux_table.getColumnModel().getColumn(j).setHeaderValue(lEtapas1.get(i).getTitulos().get(j));
                                int r = lEtapas1.get(i).getTitulos().get(j).length() *8;
                                if(r<50){ r = 50; }
                                aux_table.getColumnModel().getColumn(j).setPreferredWidth(r);
                            }
                        } else {
                            aux_table.getColumnModel().getColumn(j).setHeaderValue(" ");
                        }
                    }
                }
                aux_header = (JXTableHeader) aux_table.getTableHeader();
                aux = new JPanel(new BorderLayout());
                aux.add(aux_header, BorderLayout.NORTH);
                aux.add(aux_table, BorderLayout.CENTER);
                
            } else{
                titleTable.add(null);
                aux = new JPanel();               
            }
            
            tItens[i] = aux;           
            
        }
    }
    
    private void jbFinishedActionPerformed(java.awt.event.ActionEvent evt) {                                         
        check();
        uploadObservation();
        
        if(getProgress() == qtyBox){
            setFinished(true);
        }
        else{
            setFinished(false);
        }
        
        setVisible(false);

    }

    @SuppressWarnings("unchecked")
    // <editor-fold defaultstate="collapsed" desc="Generated Code">//GEN-BEGIN:initComponents
    private void initComponents() {

        setDefaultCloseOperation(javax.swing.WindowConstants.DISPOSE_ON_CLOSE);

        javax.swing.GroupLayout layout = new javax.swing.GroupLayout(getContentPane());
        getContentPane().setLayout(layout);
        layout.setHorizontalGroup(
            layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
            .addGap(0, 172, Short.MAX_VALUE)
        );
        layout.setVerticalGroup(
            layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
            .addGap(0, 144, Short.MAX_VALUE)
        );

        pack();
    }// </editor-fold>//GEN-END:initComponents

    /**
     * Inicializa o frame com os dados entregue pelo frame-pai
     */
    private void boot(){
    
        qtyBox = lEtapas1.size();
        titleStep = new String[qtyBox];
        descriptStep = new String[qtyBox];
        rowsTable = new ArrayList<>();
        colTable = new ArrayList<>();
        observation = "";
        
        tableItens = new ArrayList<>();
        titleTable = new ArrayList<>();
        setActive(new ArrayList<Boolean>());
        
        setTitle(name + " - " + title);
        
        cItens = new JCheckBox[qtyBox];
        tItens = new JPanel[qtyBox];
        
        initCount();
        onCloseWindows();
        constructFrame();
        
    }
    
    // Variables declaration - do not modify//GEN-BEGIN:variables
    // End of variables declaration//GEN-END:variables

    public ArrayList<Etapa> getListaDeEtapas() {
        return lEtapas1;
    }

    public void setListaDeEtapas(ArrayList<Etapa> listaDeEtapas) {
        
        this.lEtapas1 = listaDeEtapas;
        
        //Inicializa o frame com seus dados
        boot();
        
    }
    
    public boolean isFinished() {
        check();
        if ((getProgress() == qtyBox)&&(qtyBox != 0)) {
            finished = true;
        } else {
            finished = false;
        }
        return finished;
    }
    
    public void setFinished(boolean finished) {
        this.finished = finished;
    }
    
    public void setStage(int stage){
        this.stage=stage;
    }
    
    /**
     * @return the name
     */
    @Override
    public String getName() {
        return name;
    }

    /**
     * @param name the name to set
     */
    @Override
    public void setName(String name) {
        this.name = name;
    }
    
    public boolean[] getListaDeCheckBox() {
        boolean[] c = new boolean[qtyBox];
        for(int i=0; i<qtyBox; i++){
            if (cItens[i].isSelected()) {
                c[i] = true;
            } else {
                c[i] = false;
            }
        }
        return c;
    }

    void setCheckBox(boolean[] b) {
        
        int x = 0;
        for (int i=0; i<qtyBox; i++) {
            if (b[i] == true) {
                cItens[i].setSelected(true);
                cItens[i].setEnabled(true);
                cItens[i].setVisible(true);
                x = i+1;
            } else if (b[i] == false) {
                cItens[i].setSelected(false);
            }
        }
        if(x<qtyBox){
            cItens[x].setEnabled(true);
            cItens[x].setVisible(true);
        }
        
        repaint();
        validate();
    }

    /**
     * @return the tableItens
     */
    public ArrayList<ArrayList<ArrayList<String>>> getTableItens() {
        
        boolean aux_teste;
        tableItens = null;
        tableItens = new ArrayList<>();
        
        for (int i=0; i<qtyBox; i++) {
            //Array que armazena o array-de-colunas, array de linhas
            aux_teste = false;
            
            ArrayList<ArrayList<String>> aux2 = new ArrayList<>();
            for (int j = 0; j<rowsTable.get(i); j++) {
                //Array com as colunas - valores reais
                ArrayList<String> aux1 = new ArrayList<>();
                for (int k = 0; k<colTable.get(i); k++){
                    aux1.add((String) ((JXTable) tItens[i].getComponent(1)).getValueAt(j, k));
                    if(((String) ((JXTable) tItens[i].getComponent(1)).getValueAt(j, k)) != null){
                        if(!((String) ((JXTable) tItens[i].getComponent(1)).getValueAt(j, k)).equals("")){
                            aux_teste = true;
                        }
                    }
                }
                aux2.add(aux1);
            }
            tableItens.add(aux2); 
            getActive().add(aux_teste);
        }
        
        return tableItens;
    }

    /**
     * @param tableItens the tableItens to set
     */
    public void setTableItens(ArrayList<ArrayList<ArrayList<String>>> tableItens) {

        this.tableItens = tableItens;
        
        for (int i=0; i<qtyBox; i++) {
            for (int j = 0; j<rowsTable.get(i); j++) {
                for (int k = 0; k<colTable.get(i); k++){
                    ((JXTable) tItens[i].getComponent(1)).setValueAt(tableItens.get(i).get(j).get(k), j, k);
                }
            }
        }
        
        jplTable.repaint();
        jspTable.repaint();
        jtpConfig.repaint();
    }

    /**
     * @return the titleTable
     */
    public ArrayList<ArrayList<String>> getTitleTable() {
        return titleTable;
    }

    /**
     * @param titleTable the titleTable to set
     */
    public void setTitleTable(ArrayList<ArrayList<String>> titleTable) {
        this.titleTable = titleTable;
    }

    /**
     * Retorna se a planilha foi modificada ou continua em null
     */
    public ArrayList<Boolean> getActive() {
        boolean aux_teste;
        
        active = null;
        active = new ArrayList<>();
        for (int i=0; i<qtyBox; i++) {
            aux_teste = false;
            for (int j = 0; j<rowsTable.get(i); j++) {
                for (int k = 0; k<colTable.get(i); k++){
                    if(((String) ((JXTable) tItens[i].getComponent(1)).getValueAt(j, k)) != null){
                        if(!((String) ((JXTable) tItens[i].getComponent(1)).getValueAt(j, k)).equals("")){
                            aux_teste = true;
                        }
                    }
                }
            }
            active.add(aux_teste);
        }
        
        return active;
    }

    /**
     * @param active the active to set
     */
    public void setActive(ArrayList<Boolean> active) {
        this.active = active;
    }
    
    public String getPorcentagem(){
        String porcentagem = "";
        int count = 0;
        for (int j=0; j<qtyBox; j++){
            if(cItens[j].isSelected()){
                count++;
            }
            
        }
        if (qtyBox != 0) {
            porcentagem = String.valueOf((count*100)/qtyBox);
        }else {
            porcentagem = "0";
        }
        return porcentagem;
    }
    
    public String getCheckBoxMarcado() {
        String CheckBox = "";
        for (int j=0; j<qtyBox; j++){
            if(cItens[j].isSelected()) {
                CheckBox += ((JCheckBox) cItens[j]).getText() + "#" + descriptStep[j] + "#" + "1" + " - ";
            } else {
                CheckBox += ((JCheckBox) cItens[j]).getText() + "#" + descriptStep[j] + "#" + "0" + " - ";
            }
        }
        return CheckBox;
    }
    
    public int getQtyBox() {
        return qtyBox;
    }

    /**
     * @return the titleStep
     */
    public String[] getTituloEtapa() {
        return titleStep;
    }

    /**
     * @return the progress
     */
    public int getProgress() {
        return progress;
    }

    /**
     * @return the observation
     */
    public String getObservation() {
        return observation;
    }

    /**
     * @param observation the observation to set
     */
    public void setObservation(String observation) {
        this.observation = observation;
        
        jtaObservation.setText(this.observation);
    }
    
    public ArrayList<String> getTitulosTabela(int nEtapa) {
        ArrayList<String> table = titleTable.get(nEtapa-1);
        return table;
    }

    public ArrayList<ArrayList<String>> getTable(int nEtapa) {
        ArrayList<ArrayList<String>> table = tableItens.get(nEtapa-1);
        return table;
    }

    public String getNomeEtapa(int nEtapa) {
        String nomeEtapa = titleStep[nEtapa-1];
        return nomeEtapa;
    }

}
